var express = require('express')
var Msdb = require("../../../db/Mysqldb.js")
const { Date } = require('core-js')
var router = express.Router()   //可使用 express.Router 类创建模块化、可挂载的路由句柄
const jwt = require('jsonwebtoken');
const redis = require('redis');
const { promisify } = require('util');

var db = new Msdb()
var getTime=()=>{
    return new Date(new Date().getTime()+8 * 60 * 60 * 1000).toISOString().slice(0, 19).replace('T', ' ');//获取系统时间并转为数据库接受的格式
}

// 创建Redis客户端
const redisClient = redis.createClient({
  host: 'localhost',  // Redis服务器地址，根据实际情况修改
  port: 6379,          // Redis端口，默认6379
  password: '415304'
});

// 处理Redis连接错误
redisClient.on('error', (err) => {
  console.error('Redis连接错误:', err);
});

// 为Redis客户端添加Promise支持
const redisSet = promisify(redisClient.set).bind(redisClient);

// JWT密钥，实际应用中建议从环境变量获取
const JWT_SECRET = process.env.JWT_SECRET || 'PLMOP';

router.post('/login', async function(req, res) {
  // 获取数据库连接
  const connection = await db.getConnection();
  try {
    var result = await connection.execute(
      `SELECT * FROM user WHERE account=? AND password=?;`,
      [req.body.data.account, req.body.data.password]
    );
    result = result[0];
    
    if (result.length == 0) { // 账号/密码错误
      result = {
        msg: "账号/密码错误",
        code: 201
      };
    } else if (result[0].account_status == 1) { // 账号被封禁
      result = {
        msg: "账号被封禁，无法登入",
        code: 201
      };
    } else {
      // 登录成功，处理用户信息
      const user = result[0];
      user.password = ""; // 密码置空
      
      // 生成JWT令牌，只包含需要的关键信息：user_id和role_id
      const token = jwt.sign(
        { 
          user_id: user.id,   // 用户ID
          role_id: user.role_id  // 角色ID
        },  
        JWT_SECRET,
        { expiresIn: '60m' }  // 令牌有效期60分钟
      );
      
      // 将令牌存储到Redis，设置相同的过期时间
      const expireSeconds = 60 * 60; // 60分钟(秒)
      await redisSet(
        `token:${user.id}`,  // 使用用户ID作为键
        token,
        'EX',  // 设置过期时间
        expireSeconds
      );
      
      // 返回用户信息和令牌，保持原有数据结构不变
      result = {
        ...user,
        token: token,       // 新增token字段
        code: 200,
        msg: "登录成功"
      };
    }
    res.send(JSON.stringify(result));
  } catch (error) {
    // 发生错误时回滚事务
    await db.rollback(connection);
    console.error('Login error:', error);
    res.send(JSON.stringify({ code: 500, msg: '服务器错误' }));
  } finally {
    // 确保连接被释放
    connection.release();
  }
});

router.post('/insertUser', async function(req, res) { // 新增用户
    // 获取数据库连接
    const connection = await db.getConnection();
    try {
        var result = {};
        var data = req.body;
        
        // 验证上传者ID是否存在
        if (!req.auth.user_id) {
            result = {
                code: 201,
                msg: "新增失败，上传者ID不能为空！"
            };
            res.send(JSON.stringify(result));
            return;
        }
        
        if (req.auth.role_id == 1 || req.auth.role_id == 3) { // 权限校验通过
            // 检查工号是否已存在
            const users = await connection.execute(`SELECT id FROM user WHERE work_number=?`, [data.work_number]);
            
            if (users[0].length != 0) {
                result = {
                    code: 201,
                    msg: "新增失败，当前工号已经存在！"
                };
                res.send(JSON.stringify(result));
                return;
            }
            
            await db.beginTransaction(connection); // 开始事务
            
            // 获取当前时间作为创建时间
            const createTime = getTime();
            
            // 新增用户 - 增加insert_user_id和create_time字段
            await connection.execute(
                `INSERT INTO user (
                    account, password, name, role_id, phone, work_number, 
                    framework_id, position, birthday, board_date, 
                    insert_user_id, create_time
                ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?)`, 
                [
                    data.work_number, 
                    data.password, 
                    data.name, 
                    data.role_id, 
                    data.phone, 
                    data.work_number, 
                    data.framework_id, 
                    data.position, 
                    data.birthday, 
                    data.board_date,
                    req.auth.user_id,  // 上传者ID
                    createTime     // 创建时间
                ]
            );
            
            // 动态拼接日志描述，只包含有值的字段
            const fieldMap = {
                work_number: '工号',
                name: '姓名',
                role_id: '角色ID',
                phone: '电话',
                framework_id: '所属部门',
                position: '职位',
                birthday: '生日',
                board_date: '入职日期',
                insert_user_id: '上传者ID' // 日志中添加上传者信息
            };
            
            // 初始日志内容
            let logParts = [`用户ID: ${req.auth.user_id} 新增用户`];
            
            // 遍历字段，只添加有值的字段
            Object.keys(fieldMap).forEach(field => {
                // 对于insert_user_id，使用已验证存在的data.user_id
                const value = field === 'insert_user_id' ? data.user_id : data[field];
                if (value !== undefined && value !== null && value !== '') {
                    logParts.push(`${fieldMap[field]}: ${value}`);
                }
            });
            
            // 组合成完整日志
            const operationDesc = logParts.join('，') + ';';
            const time = getTime();
            
            // 插入操作日志
            await connection.execute(
                `INSERT INTO operation_log (user_id, sql_words, time) VALUES (?,?,?);`, 
                [
                    req.auth.user_id, 
                    operationDesc, 
                    time
                ]
            );
            
            await db.commit(connection); // 提交事务
            result = {
                code: 200,
                msg: "新增成功"
            };
        } else {
            result = {
                code: 201,
                msg: "当前账号不属于超级管理员/系统运维专员，无法新增用户！"
            };
        }
        res.send(JSON.stringify(result));
    } catch (error) {
        // 发生错误时回滚事务
        await db.rollback(connection);
        res.send(JSON.stringify({ code: 500, msg: '服务器错误' }));
    } finally {
        // 确保连接被释放
        connection.release();
    }
});

router.post('/updatePassword',async function(req,res){
    // 获取数据库连接
    const connection = await db.getConnection();
    try {
        await db.beginTransaction(connection); // 开始事务
        
        var result = await connection.execute(`UPDATE user SET password=? WHERE id=?;`,[req.body.data.password,req.body.data.id]);
        result = result[0];
        
        if(result.affectedRows==0){
            await db.rollback(connection); // 回滚事务
            result={}
            result.msg = "密码更新错误"
            result.code=201
        } else {
            result.msg = "更新成功"
            result.code=200
            var sql_words=`UPDATE user SET password=${req.body.data.password} WHERE id=${req.body.data.id};`
            var time=getTime()
            await connection.execute(`INSERT INTO operation_log (user_id,sql_words,time) VALUES (?,?,?);`,[req.body.data.id,sql_words,time]);
            await db.commit(connection); // 提交事务
        }
        res.send(JSON.stringify(result));
    } catch (error) {
        // 发生错误时回滚事务
        await db.rollback(connection);
        console.error('Update password error:', error);
        res.send(JSON.stringify({ code: 500, msg: '服务器错误' }));
    } finally {
        // 确保连接被释放
        connection.release();
    }
})

router.post('/insertUser', async function(req, res) { // 新增用户
    // 获取数据库连接
    const connection = await db.getConnection();
    try {
        var result = {};
        var data = req.body;
        
        if (data.insert_role_id == 1 || data.insert_role_id == 3) { // 权限校验通过
            const users = await connection.execute(`SELECT id FROM user WHERE work_number=?`, [data.work_number]);
            
            if (users[0].length != 0) {
                result = {
                    code: 201,
                    msg: "新增失败，当前工号已经存在！"
                };
                res.send(JSON.stringify(result));
                return;
            }
            
            await db.beginTransaction(connection); // 开始事务
            
            // 新增用户
            await connection.execute(`INSERT INTO user (account,password,name,role_id,phone,work_number,framework_id,position,birthday,board_date) 
                VALUES (?,?,?,?,?,?,?,?,?,?)`, [
                data.work_number, 
                data.password, 
                data.name, 
                data.role_id, 
                data.phone, 
                data.work_number, 
                data.framework_id, 
                data.position, 
                data.birthday, 
                data.board_date
            ]);
            
            // 动态拼接日志描述，只包含有值的字段
            const fieldMap = {
                work_number: '工号',
                name: '姓名',
                role_id: '角色ID',
                phone: '电话',
                framework_id: '所属部门',
                position: '职位',
                birthday: '生日',
                board_date: '入职日期'
            };
            
            // 初始日志内容
            let logParts = [`用户ID: ${data.user_id} 新增用户`];
            
            // 遍历字段，只添加有值的字段
            Object.keys(fieldMap).forEach(field => {
                if (data[field] !== undefined && data[field] !== null && data[field] !== '') {
                    logParts.push(`${fieldMap[field]}: ${data[field]}`);
                }
            });
            
            // 组合成完整日志
            const operationDesc = logParts.join('，') + ';';
            const time = getTime();
            
            // 插入操作日志
            await connection.execute(`INSERT INTO operation_log (user_id, sql_words, time) VALUES (?,?,?);`, [
                data.user_id, 
                operationDesc, 
                time
            ]);
            
            await db.commit(connection); // 提交事务
            result = {
                code: 200,
                msg: "新增成功"
            };
        } else {
            result = {
                code: 201,
                msg: "当前账号不属于超级管理员/系统运维专员，无法新增用户！"
            };
        }
        res.send(JSON.stringify(result));
    } catch (error) {
        // 发生错误时回滚事务
        await db.rollback(connection);
        console.error('Insert user error:', error);
        res.send(JSON.stringify({ code: 500, msg: '服务器错误' }));
    } finally {
        // 确保连接被释放
        connection.release();
    }
});

router.post('/searchUser',async function(req,res){//搜索用户
    var result={}
    var data=req.body
    var sql="SELECT * FROM user WHERE 1=1"//全查语句
    var getTotalSql="SELECT COUNT(*) AS total FROM user WHERE 1=1"//获取总数语句
    var params=[]//参数
    for(const key in data.condition){//遍历查询条件
        if(data.condition[key]!=null){
            sql+=` AND ${key}=?`
            getTotalSql+=` AND ${key}=?`
            params.push(data.condition[key])
        }
    }
    var [total]=await db.query(getTotalSql,params)
    sql+=" LIMIT ? OFFSET ?"//进行分页操作，分别为页大小与页偏移
    params.push(data.pageSize)
    params.push(data.offset)
    var users=await db.query(sql,params)
    result={
        data:users,
        code:200,
        msg:"查询成功~",
        total:total.total
    }
    res.send(JSON.stringify(result))
})

router.post('/getUserInfo',async function(req,res){//获取用户的详细信息
    var result={}
    var data=req.body
    var userDeatil=await db.query(`SELECT * FROM user WHERE id=?`,[data.user_id])
    result={
        data:userDeatil[0],
        msg:"查询成功~",
        code:200
    }
    res.send(JSON.stringify(result))
})

router.post('/updateUserInfo', async function(req, res) { // 更新用户的详细信息
    // 获取数据库连接
    const connection = await db.getConnection();
    try {
        let result = {};
        const data = { ...req.body };
        
        // 1. 权限校验
        if (![1, 3].includes(req.auth.role_id)) {
            result = {
                code: 403,
                msg: "当前账号不属于超级管理员/系统运维专员，无法更新用户！"
            };
            return res.json(result);
        }
        
        // 2. 特殊限制校验
        if (data.role_id === 1) {
            result = {
                code: 400,
                msg: "不允许新增/修改超级管理员账号！"
            };
            return res.json(result);
        }
        
        if (data.framework_id === 1) {
            result = {
                code: 400,
                msg: "不允许在根节点下挂载用户！"
            };
            return res.json(result);
        }
        
        // 3. 查询原始用户数据用于比较
        const [originalRows] = await connection.execute(
            'SELECT * FROM user WHERE account = ?',
            [data.account]
        );
        
        if (originalRows.length === 0) {
            result = { code: 404, msg: "用户记录不存在" };
            return res.json(result);
        }
        const originalData = originalRows[0];
        
        // 4. 定义需要检查的字段
        const fieldsToCheck = [
            'name', 'role_id', 'phone', 'framework_id', 'position',
            'user_status', 'account_status', 'birthday', 'board_date'
        ];
        
        // 5. 比较字段变化
        const changes = [];
        const updateFields = [];
        const updateValues = [];
        
        fieldsToCheck.forEach(field => {
            const newValue = data[field];
            const oldValue = originalData[field];
            
            // 处理null和空值的比较
            const isDifferent = JSON.stringify(newValue) !== JSON.stringify(oldValue);
            if (isDifferent) {
                changes.push({
                    field,
                    oldValue: oldValue ?? '空',
                    newValue: newValue ?? '空'
                });
                updateFields.push(`${field} = ?`);
                updateValues.push(newValue);
            }
        });
        
        // 6. 没有变化则不执行更新
        if (changes.length === 0) {
            result = { 
                code: 200, 
                msg: "没有需要更新的内容" 
            };
            return res.json(result);
        }
        
        // 7. 有变化则执行更新
        updateValues.push(data.account); // WHERE条件的值
        
        // 开启事务
        await db.beginTransaction(connection);
        
        // 执行更新（只更新变化的字段）
        await connection.execute(
            `UPDATE user SET ${updateFields.join(', ')} WHERE account = ?`,
            updateValues
        );
        
        // 8. 记录操作日志（包含具体变更内容）
        const changeDescription = changes.map(change => 
            `${change.field}: ${change.oldValue} → ${change.newValue}`
        ).join('; ');
        
        const logMessage = `用户ID: ${req.auth.user_id} 更新了用户账号: ${data.account}，变更内容: ${changeDescription}`;
        const time = getTime();
        
        await connection.execute(
            `INSERT INTO operation_log (user_id, sql_words, time) VALUES (?, ?, ?);`,
            [req.auth.user_id, logMessage, time]
        );
        
        // 提交事务
        await db.commit(connection);
        
        result = {
            code: 200,
            msg: "更新成功！",
            changes: changes // 返回变更内容给前端
        };
        
        res.json(result);
    } catch (error) {
        // 发生错误时回滚事务
        await db.rollback(connection);
        console.error('Update user info error:', error);
        res.json({ code: 500, msg: '服务器错误' });
    } finally {
        // 确保连接被释放
        connection.release();
    }
});

router.get('/getAfterSalesUsers',async function(req,res){//获取售后人员
    var result=[]
    var users=await db.query(`SELECT * FROM user WHERE role_id=9`)
    for(var i=0;i<users.length;i++){
        result.push({
            value:users[i].id,
            label:users[i].name+"[工号："+users[i].work_number+"]"
        })
    }
    res.send(JSON.stringify(result))
})

module.exports = router